home *** CD-ROM | disk | FTP | other *** search
/ Aminet 8 / Aminet 8 (1995)(GTI - Schatztruhe)[!][Oct 1995].iso / Aminet / comm / misc / LogTime.lha / LogTime / LogTime.c < prev    next >
C/C++ Source or Header  |  1995-09-02  |  8KB  |  308 lines
  1. static const char *rcsid = "$Id: LogTime.c,v 1.18 1995/09/02 21:45:44 mleining Exp mleining $";
  2. static const char *version = "Version $VER: $Revision: 1.18 $";
  3. /*
  4.  * Copyright (c) 1995, Marvin James (Jim) Leininger, Jr
  5.  *                     mleining@metrolink.net
  6.  *                     All Rights Reserved.
  7.  * 
  8.  * this program is a quick hack to time my ppp connections
  9.  * 
  10.  * I'm providing it "as is" because I thought other's might 
  11.  * find it useful.
  12.  * 
  13.  * To use it:
  14.  * 
  15.  * 0. copy LogTime to someplace in your path, probably
  16.  * AmiTCP:bin or c:
  17.  * 
  18.  * 1. when you connect to your on-line service, run LogTime.
  19.  * (if you don't want the timer output, 
  20.  * use "run >nil: <nil: Logtime <nil: >nil:")
  21.  * (a good place to do this is in your startppp
  22.  * or startnet script).
  23.  * 
  24.  * 2. when you disconnect from your on-line service, 
  25.  * run logtime with the -s option.
  26.  * (a good place to do this is in your stopppp
  27.  * or stopnet script).
  28.  * 
  29.  * 3. once a month (usually on your billing cutoff date), run
  30.  * LogTime with the -r option, to reset the timer to zero.
  31.  * If you run a cron program, you can add lines to your 
  32.  * crontab to print your current monthly usage (logtime -p)
  33.  * and then reset the counter (logtime -r).
  34.  * 
  35.  * 4. Logtime writes it's time to ENV:LogTimeValue and ENVARC:LogTimeValue,
  36.  * so you can access the current time from those files,
  37.  * or with the environment functions.  I know this is a hack,
  38.  * but I didn't want to take the time to figure out the right
  39.  * way to do this.  It also uses ENV:LogTimeCmd to send itself
  40.  * commands.
  41.  * 
  42.  *    
  43.  *    Standard Disclaimer
  44.  *   -------------------
  45.  *
  46.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, 
  47.  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY 
  48.  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL 
  49.  * I BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, 
  50.  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
  51.  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
  52.  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
  53.  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
  54.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 
  55.  * THE POSSIBILITY OF SUCH DAMAGE.
  56.  */
  57.  
  58. #include <ctype.h>
  59. #include <stdio.h>
  60. #include <string.h>
  61. #include <fcntl.h>
  62. #include <time.h>
  63. #include <assert.h>
  64. /*
  65.  * #include <machine/limits.h> defines clock tick as 60 which is wrong! 
  66.  */
  67. #define CLK_TCK 50
  68. #include <signal.h>
  69.  
  70. /*
  71.  *     Amigados Delay Function
  72.  *     timeout is in clock ticks (CLK_TCK) 
  73.  */
  74. void      Delay (long timeout);
  75.  
  76. #ifndef FALSE
  77. #define FALSE 0
  78. #define TRUE 1
  79. #endif
  80.  
  81. /*
  82.  * * Local Data Declarations
  83.  */
  84. #define        readonly         "r"
  85. #define        writeonly        "w"
  86.  
  87. char     *myname;
  88.  
  89. /*
  90.  * hack to use env/envarc to store my timer 
  91.  */
  92. FILE     *envfd;
  93. char      envfile[80] = "ENV:LogTimeValue";
  94. FILE     *envarcfd;
  95. char      envarcfile[80] = "ENVARC:LogTimeValue";
  96. FILE     *cmdfd;
  97. char      cmdfile[80] = "ENV:LogTimeCmd";
  98. int       scanfresult;
  99.  
  100. /*
  101.  * values to place in ENV:LogTimeCmd 
  102.  */
  103. #define LOGTIME_NO_COMMAND 0
  104. #define LOGTIME_STOP 1
  105.  
  106. #define LOGTIME_NO_STATUS 0
  107. #define LOGTIME_RUNNING 1
  108.  
  109. void
  110. usage (myname)
  111.      char     *myname;
  112. {
  113.     fprintf (stderr, "%s\n", rcsid);
  114.     fprintf (stderr, "%s\n", version);
  115.     fprintf (stderr, "\n");
  116.     fprintf (stderr, "Usage: %s [-rpsv]\n", myname);
  117.     fprintf (stderr, "\n");
  118.     fprintf (stderr, "   Copyright © 1995, Marvin James Leininger, Jr.\n");
  119.     fprintf (stderr, "                     <mleining@metrolink.net>\n");
  120.     fprintf (stderr, "                     All rights reserved.\n");
  121.     fprintf (stderr, "\n");
  122.     fprintf (stderr,
  123.       "  Use ctrl-c, break C <processid>, or %s -s to stop.\n", myname);
  124.     fprintf (stderr, "  -r = reset timer to zero\n");
  125.     fprintf (stderr, "  -p = print current time value and exit\n");
  126.     fprintf (stderr, "  -s = stop a running logtime\n");
  127.     fprintf (stderr, "  -v = this message\n");
  128.     exit (1);
  129. };
  130.  
  131. int
  132. main (argc, argv)
  133.      char    **argv;
  134.      int       argc;
  135. {
  136.     register char *p;
  137.     static unsigned int cmdvalue;
  138.     static time_t *timeval = 0;
  139.     static unsigned long timeint = 0;
  140.     static unsigned long timerval = 0;
  141.     static unsigned long lasttimerval = 0;
  142.     static unsigned long starttime = 0;
  143.     static int reset_timer = FALSE;
  144.     static int stop_command = FALSE;
  145.     static int print_only = FALSE;
  146.     static unsigned long timer_hours;
  147.     static unsigned long timer_minutes;
  148.  
  149.     /*
  150.      * clock ticks to wait, CLK_TCK == 1 second 
  151.      * check time every 10 seconds.  Normally I would set
  152.      * this longer, but it there was no quick and dirty
  153.      * way to kill the program until it comes out of the
  154.      * delay.  A signal handler might work....
  155.      */
  156.     static const long waittime = CLK_TCK * 10L;
  157.  
  158.     /*
  159.      * read the program name and arguments 
  160.      */
  161.     myname = (argc-- < 1) ? "LOGTIME" : *argv++;
  162.  
  163.     /*
  164.      * read the command line options
  165.      */
  166.     while ((argc > 0) && (**argv == '-')) {
  167.     argc--;            /*
  168.                  * one less argument to process 
  169.                  */
  170.     p = *argv++;        /*
  171.                  * process the current argument 
  172.                  */
  173.     while (*++p != '\0') {
  174.         switch (*p) {
  175.         case 'v':        /*
  176.                  * help 
  177.                  */
  178.         usage (myname);
  179.         break;
  180.         case 'r':
  181.         reset_timer = TRUE;
  182.         break;
  183.         case 's':
  184.         cmdfd = fopen (cmdfile, writeonly);
  185.         assert (cmdfd);
  186.         fprintf (cmdfd, "%u", LOGTIME_STOP);
  187.         fclose (cmdfd);
  188.         Delay (waittime);
  189.         cmdfd = fopen (cmdfile, writeonly);
  190.         assert (cmdfd);
  191.         fprintf (cmdfd, "%u", LOGTIME_NO_COMMAND);
  192.         fclose (cmdfd);
  193.         stop_command = TRUE;
  194.         break;
  195.         case 'p':
  196.         print_only = TRUE;
  197.         break;
  198.         default:        /*
  199.                  * undefined option 
  200.                  */
  201.         usage (myname);
  202.         break;
  203.         };
  204.     };
  205.     };
  206.  
  207.     /*
  208.      * attempt to read an existing logtime file 
  209.      */
  210.     envarcfd = fopen (envarcfile, readonly);
  211.     if ((envarcfd == NULL) || reset_timer) {
  212.     /*
  213.      * if there is no existing file, then create one 
  214.      */
  215.     printf ("Resetting Timer\n");
  216.     fclose (envarcfd);
  217.     envarcfd = fopen (envarcfile, writeonly);
  218.     assert (envarcfd);
  219.     fprintf (envarcfd, "%lu", timerval);
  220.     fclose (envarcfd);
  221.     envfd = fopen (envfile, writeonly);
  222.     assert (envfd);
  223.     fprintf (envfd, "%lu", timerval);
  224.     fclose (envfd);
  225.     } else {            /*
  226.                  * the environment variable file already exists 
  227.                  */
  228.     scanfresult = fscanf (envarcfd, "%lu", &timerval);
  229.     if (scanfresult == 1) {
  230.         fclose (envarcfd);
  231.         envfd = fopen (envfile, writeonly);
  232.         fprintf (envfd, "%lu", timerval);
  233.         fclose (envfd);
  234.     } else {
  235.         fprintf (stderr, "Error reading environment variable file\n");
  236.         assert (0);
  237.     };
  238.     };
  239.  
  240.     if (reset_timer || stop_command) {
  241.     exit (0);
  242.     };
  243.  
  244.     /*
  245.      * adjust start time to reflect time saved in file 
  246.      */
  247.     timeint = time (timeval);    /*
  248.                  * get the time from the system 
  249.                  */
  250.     timer_hours = timerval / 60L;
  251.     timer_minutes = timerval % 60L;
  252.  
  253.     if (print_only) {
  254.         printf ("Online timer (hours:min): %5.5lu:%2.2lu\n", timer_hours, timer_minutes);
  255.         fflush (stdout);
  256.     exit (0);
  257.     };
  258.  
  259.     /*
  260.      * now that we've initialized our timers, start counting 
  261.      */
  262.     starttime = timeint - (timerval * 60L);
  263.     while (TRUE) {
  264.     /*
  265.      * only write if time has changed 
  266.      */
  267.     if (timerval != lasttimerval) {
  268.         envarcfd = fopen (envarcfile, writeonly);
  269.         assert (envarcfd);
  270.         fprintf (envarcfd, "%lu", timerval);
  271.         fclose (envarcfd);
  272.         envfd = fopen (envfile, writeonly);
  273.         assert (envfd);
  274.         fprintf (envfd, "%lu", timerval);
  275.         fclose (envfd);
  276.     };
  277.     /*
  278.      * check for a command 
  279.      */
  280.     cmdfd = fopen (cmdfile, readonly);
  281.     if (cmdfd != NULL) {
  282.         scanfresult = fscanf (cmdfd, "%u", &cmdvalue);
  283.         fclose (cmdfd);
  284.         switch (cmdvalue) {
  285.         case LOGTIME_NO_COMMAND:
  286.         break;
  287.         case LOGTIME_STOP:
  288.                 printf ("\n");
  289.                 fflush (stdout);
  290.         exit (0);
  291.         break;
  292.         default:
  293.         break;
  294.         };
  295.     };
  296.     Delay (waittime);
  297.     timeint = time (timeval);    /*
  298.                      * get the time from the system 
  299.                      */
  300.     lasttimerval = timerval;
  301.     timerval = (timeint - starttime) / 60L;
  302.     timer_hours = timerval / 60L;
  303.     timer_minutes = timerval % 60L;
  304.     printf (" Online timer (hours:min): %5.5lu:%2.2lu \r", timer_hours, timer_minutes);
  305.     fflush (stdout);
  306.     };
  307. };
  308.